package adapter;

import java.rmi.*;
import java.net.*;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.*;
import java.util.ArrayList;
import java.util.List;

import javax.naming.*;

import server.fassade.IFlughafenController;

import server.ejb.beans.Bahn;
import server.ejb.beans.Fluggesellschaft;
import server.ejb.beans.Flugzeug;
import server.ejb.beans.Flugzeugtyp;
import server.ejb.beans.Gebuehr;
import server.ejb.beans.Parkposition;
import server.ejb.beans.Lotse;

public class Adapter extends UnicastRemoteObject implements IAdapter 
{
	private static final long serialVersionUID = 0L;

	private int m_RMIPort;
	private String m_RMIHost;
	private String m_RMIServerURL;
	private IFlughafenController fassade = null; 
	
	private List<IClientCallback> clientList = new ArrayList<IClientCallback>();
	
	public Adapter(String n_RMIHost, int n_RMIPort) throws RemoteException 
	{
		m_RMIPort = n_RMIPort;
		m_RMIHost = n_RMIHost;
		m_RMIServerURL = String.format("rmi://%s:%d/FlughafenAdapter", m_RMIHost, m_RMIPort);
		
		try 
		{	
			// Start RMI registry and bind to it 	
			LocateRegistry.createRegistry(m_RMIPort);
			LocateRegistry.getRegistry();
			Naming.rebind(m_RMIServerURL, this);
			System.out.println("Adapter connected to RMI Registry: " + m_RMIServerURL);
			
			try
			{
				// Connect to EJB server
				InitialContext ctx = new InitialContext();
				fassade = (IFlughafenController)ctx.lookup("FlugzeugEAR/LandungBean/remote");
				//fassade = (IFlughafenController)ctx.lookup("Flughafen/LandungBean/remote-landeanflug.IFlughafenController");
				System.out.println("Adapter connected to JNDI - Server");
				if(null == fassade)
				{
					System.out.println("Fassade is NULL");
				}
			}
			catch (Exception e)
			{
				System.out.println("Error");
				throw e;
			}
		} 
		catch (MalformedURLException e) 
		{
			System.out.println("URL ungÃ¼ltig:\n" + e.getMessage());
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}

	public static void main(String[] args) 
	{
		try 
		{
			new Adapter("127.0.0.1",1001);
		} 
		
		catch (RemoteException e) 
		{
			System.out.println("Fehler beim Instanziieren");
		}
	}
	
	@Override
	public void registerClientCallback(IClientCallback client)
	{
		if ((null != client)&&(false == clientList.contains(client)))
		{
			clientList.add(client);
			System.out.println("Client registerd");
		}
		else
		{
			System.out.println("Failed to registerd client");
		}
	}

	@Override
	public void unregisterClientCallback(IClientCallback client)
	{
		if ((null != client)&&(true == clientList.contains(client)))
		{
			clientList.remove(client);
			System.out.println("Client unregisterd");
		}
		else
		{
			System.out.println("Failed to unregisterd client");
		}
	}

	
	@Override
	public void createFluggeselschaft(String name) throws RemoteException {
		fassade.createFluggeselschaft(name);
	}

	@Override
	public void createLandeStartbahn() throws RemoteException {
		fassade.createBahn();
	}
		
	@Override
	public List<Flugzeug> getFlugzeuge() throws RemoteException {
		return fassade.getFlugzeuge();
	}

	@Override
	public List<Flugzeugtyp> getFlugzeugtypen() throws RemoteException {
		return fassade.getFlugzeugtypen();
	}

	@Override
	public List<Fluggesellschaft> getFluggeselschaften() throws RemoteException {
		return fassade.getFluggesellschaften();
	}

	@Override
	public List<Bahn> getLandeStartbahnen() throws RemoteException {
		return fassade.getBahnen();
	}

	@Override
	public List<Parkposition> getParkpositionen() throws RemoteException {
		return fassade.getParkpositionen();
	}

	@Override
	public void notifyObservers() throws RemoteException 
	{
		for(IClientCallback client : clientList)
		{
			if(null!=client)
			{
				try
				{
					client.update(this);
				}
				catch(RemoteException e)
				{
					e.printStackTrace();
				}
			}
		}
	}

	@Override
	public void createFlugzeug(String bezeichnung, Flugzeugtyp flugzeugtyp, Fluggesellschaft fluggesellschaft) throws RemoteException 
	{
		fassade.createFlugzeug(bezeichnung, flugzeugtyp, fluggesellschaft);
	}

	@Override
	public void createFlugzeugTyp(String bezeichnung, Gebuehr gebuehr)throws RemoteException 
	{
		fassade.createFlugzeugTyp(bezeichnung, gebuehr); 
	}

	@Override
	public void createParkposition() throws RemoteException 
	{
		fassade.createParkposition();
	}

	@Override
	public void setLandebahnStatus(int ID, boolean besetzt)throws RemoteException 
	{
		fassade.setLandebahnStatus(ID, besetzt);
	}

	@Override
	public void setParkpositionStatus(int ID, boolean besetzt) throws RemoteException {
		fassade.setParkpositionStatus(ID, besetzt);
	}

	@Override
	public List<Lotse> getLotsen() throws RemoteException {
		return fassade.getLotsen();
	}

	@Override
	public void setSollZeit(String zeit) throws RemoteException {
		fassade.setSollZeit(zeit);
	}

	@Override
	public void setSollDatum(String datum) throws RemoteException {
		fassade.setSollDatum(datum);
	}

	@Override
	public void setIstZeit(String zeit) throws RemoteException {
		fassade.setIstZeit(zeit);
	}

	@Override
	public void setIstDatum(String datum) throws RemoteException {
		fassade.setIstDatum(datum);
	}

	@Override
	public Flugzeug getFlugzeug(int ID) throws RemoteException {
		return fassade.getFlugzeug(ID);
	}

	@Override
	public Flugzeugtyp getFlugzeugtyp(int ID) throws RemoteException {
		return fassade.getFlugzeugtyp(ID);
	}

	@Override
	public Fluggesellschaft getFluggeselschaft(int ID) throws RemoteException {
		return fassade.getFluggeselschaft(ID);
	}

	@Override
	public Bahn getStartLangebahn(int ID) throws RemoteException {
		return fassade.getStartLangebahn(ID);
	}

	@Override
	public Parkposition getParkposition(int ID) throws RemoteException {
		return fassade.getParkposition(ID);
	}
}